package _5_learn_arrays_slices

import (
	"fmt"
	"strconv"
)

// 1. var 数组变量名 [元素数量]T
// var cites = [3]string{}

// 2. 一般情况下我们可以让编译器根据初始值的个数自行推断数组的长度，例如：
// var all_cites = [...]string{}

// 3. 我们还可以使用指定索引值的方式来初始化数组，例如:
// a := [...]int{1: 1, 3: 5}

// 数组是同一类型的数据的结合
var (
	// 4. 二维数组
	a = [3][2][1]string{
		{{"北京"}, {"上海"}},
		{{"广州"}, {"深圳"}},
		{{"成都"}, {"重庆"}},
	}
)

func arrayAsArguments(a *[5]int) {
	a[1] = 1
	fmt.Println("函数内部的数组:", a)
}

// 计算数组之和
func Sum(numbers []int) int {
	numbers = append(numbers, 1, 2, 3)
	sum := 0
	for index, number := range numbers {
		sum += number
		sum += index
	}
	return sum
}

// 通过普通 for 循环计算数组总和
func Sum1(numbers []int) int {
	sum := 0
	for i := 0; i < len(numbers); i++ {
		sum += numbers[i]
	}
	return sum
}

// SumAllTails calculates the sums of all but the first number given a collection of slices.
func SumAllTails(numbersToSum ...[]int) []int {
	var sums []int
	for _, numbers := range numbersToSum {
		if len(numbers) == 0 {
			sums = append(sums, 0)
		} else {
			tail := numbers[1:]
			sums = append(sums, Sum(tail))
		}
	}

	return sums
}

// 关于切片
func getSlice() {
	var malice []int
	malice = []int{2, 4}
	malice = append(malice, 2)
	ss := []int{1, 2, 4, 5}
	// 切片增加元素
	ss = append(ss, 5)
	length := len(ss)

	fmt.Println(length)
}

func genSlice(slices *[]int) []string {
	// T:切片的元素类型
	// size:切片中元素的数量
	// cap:切片的容量
	// make([]T,size,cap)

	_slice := *slices

	fmt.Printf("slices 的内存的地址%p\n", slices)
	fmt.Printf("_slice 的内存的地址%p\n", _slice)

	mySlice := make([]string, 3, 1)
	for i := 0; i < len(_slice); i++ {
		//mySlice = append(mySlice, string(_slice[i]))
		mySlice = append(mySlice, strconv.Itoa(_slice[i]))

	}

	b := strconv.FormatBool(true)
	fmt.Println(b)
	return mySlice
}

func main() {
	//a := [5]int{}
	//arrayAsArguments(&a)
	//fmt.Println("函数外部的数组:", a)

	var s1 = []int{1, 2, 3}
	fmt.Printf("s1 的内存的地址%p\n", s1)

	genSlice(&s1)

	//	编译器推导数组畅读
	var bools = [...]bool{true, false}

	//	使用索引初始化
	bools2 := [...]bool{
		1: true,
		3: false,
	}

	for i := 0; i < len(bools2); i++ {
		fmt.Println(bools2[i])
	}

	for index, value := range bools2 {
		fmt.Println(index)
		fmt.Println(value)
	}

	//	二维数组：3个长度为2的数组，多维数组只能在最外层推导长度
	var cityss = [3][2]string{
		{"city1", "city2"},
		{"city3", "city4"},
	}

	// 遍历二维数组
	for _, city := range cityss {
		for _, city2 := range city {
			fmt.Println(city2)
		}
	}

	//	数组是值传递，包括函数参数和变量再次声明，都是复制一份副本一个新的内存空间
}

// make 可以在创建切片的时候指定我们需要的长度和容量
func getArray(arr [5]int) {
	for _, key := range arr {
		//遍历数组
	}
}
